// use std::sync::Arc;

// use axum::{
// extract::{Extension, Json, Path},
// routing::{get, post},
// Router,
// };

// use serde::Deserialize;
// use tokio::sync::Mutex;
// use tracing::info;

// use bc_lib::wallet::{Utxo, Wallet};
// use bc_lib::consensus::{Block, Consensus};

// use bc_base::transaction::{BlockChainTxOutPoint, TransactionId, TransactionValue};
// use bc_base::{self, PublicKeyBytes};
// use crate::p2p::P2PNetwork;

// #[cfg(test)]
// mod tests_new {
//     use super::*;
//     use axum::body::Body;
//     // use axum::http::{request, response, Request, StatusCode};
//     use axum::http::{Request, StatusCode};
//     // use axum::response::Response;
//     use axum::routing::get;
//     use axum::Router;
//     // use std::net::SocketAddr;
//     // use tokio::net::TcpListener;
//     use tower::{Service, ServiceExt};
//     // use tower::Service;

//     #[tokio::test]
//     async fn test_create_keypair() {
//         println!("test_create_keypair");
//         let router = Router::new().route("/create_keypair", get(BcManager::create_keypair));
//         println!("router: {:?}", router);
//         let request = Request::builder()
//             .uri("/create_keypair")
//             .method("GET")
//             .body(Body::empty())
//             .unwrap();
//         println!("request: {:?}", request);
//         let response = router.oneshot(request).await.unwrap();
//         println!("response: {:?}", response);
//         assert_eq!(response.status(), StatusCode::OK);
//     }

//     #[tokio::test]
//     async fn test_send_transaction() {
//         let app = Router::new().route("/send_transaction", post(BcManager::send_transaction));
//         let response = app
//             .clone()
//             .into_service()
//             .call(
//                 Request::builder()
//                     .uri("/send_transaction")
//                     .method("POST")
//                     .body(Body::from(
//                         r#"{"sender": "sender", "recipient": "recipient", "amount": 100}"#,
//                     ))
//                     .unwrap(),
//             )
//             .await
//             .unwrap();

//         assert_eq!(response.status(), StatusCode::OK);
//     }

//     #[tokio::test]
//     async fn test_query_balance() {
//         let app = Router::new().route("/query_balance/:owner", get(BcManager::query_balance));
//         let response = app
//             .clone()
//             .into_service()
//             .call(
//                 Request::builder()
//                     .uri("/query_balance/owner")
//                     .method("GET")
//                     .body(Body::empty())
//                     .unwrap(),
//             )
//             .await
//             .unwrap();

//         assert_eq!(response.status(), StatusCode::OK);
//     }

//     #[tokio::test]
//     async fn test_mine_block() {
//         let app = Router::new().route("/mine_block/:owner", get(BcManager::mine_block));
//         let response = app
//             .clone()
//             .into_service()
//             .call(
//                 Request::builder()
//                     .uri("/mine_block/owner")
//                     .method("GET")
//                     .body(Body::empty())
//                     .unwrap(),
//             )
//             .await
//             .unwrap();

//         assert_eq!(response.status(), StatusCode::OK);
//     }

//     #[tokio::test]
//     async fn test_query_transactions() {
//         let app = Router::new().route("/transactions", get(BcManager::query_transactions));
//         let response = app
//             .clone()
//             .into_service()
//             .call(
//                 Request::builder()
//                     .uri("/transactions")
//                     .method("GET")
//                     .body(Body::empty())
//                     .unwrap(),
//             )
//             .await
//             .unwrap();

//         assert_eq!(response.status(), StatusCode::OK);
//     }

//     // #[tokio::test]
//     // async fn test_server() {
//     //     let server = Server::new();
//     //     let addr = SocketAddr::from(([127, 0, 0, 1], 0));
//     //     let listener = TcpListener::bind(addr).await.unwrap();
//     //     let addr = listener.local_addr().unwrap();

//     //     let server_task = tokio::spawn(async move {
//     //         server.start().await;
//     //     });

//     //     let client = reqwest::Client::new();
//     //     let response = client.get(format!("http://{}", addr)).send().await.unwrap();

//     //     assert_eq!(response.status(), StatusCode::OK);

//     //     server_task.abort();
//     // }
// }

#[cfg(test)]
mod tests_gpt {
    use axum::{
        Router,
        body::Body,
        extract::Json,
        http::{Request, StatusCode},
        routing::get,
    };

    use serde_json::{Value, json};
    use tower::ServiceExt; // 提供 `.oneshot()` 方法

    async fn hello_json() -> Json<serde_json::Value> {
        Json(json!({ "message": "Hello, Axum!" }))
    }

    #[tokio::test]
    async fn test_hello() {
        let app = Router::new().route("/", get(hello_json));

        let request = Request::builder()
            .uri("/")
            .method("GET")
            .body(Body::empty())
            .unwrap();

        let response = app.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = response.into_body();
        let body_bytes = axum::body::to_bytes(body, 100).await.unwrap();
        let json_response: Value = serde_json::from_slice(&body_bytes).unwrap();

        assert_eq!(json_response, json!({ "message": "Hello, Axum!" }));
    }

    async fn hello_world() -> &'static str {
        "Hello, world!"
    }

    #[tokio::test]
    async fn hello_world_test() {
        let app = Router::new().route("/", get(hello_world));

        // Create a request to send to the handler.
        let response = app
            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
            .await
            .unwrap();

        // Check that the response is what we expect.
        assert_eq!(response.status(), StatusCode::OK);

        // let body = hyper::body::to_bytes(response).await.unwrap();
        let body = response.into_body();
        let body = axum::body::to_bytes(body, 100).await.unwrap();
        assert_eq!(&body[..], b"Hello, world!");
    }
}
